Python Kodekvalitet: Mestring av Black, Flake8 og mypy-integrasjon

I en verden av programvareutvikling er det å skrive funksjonell kode bare halve jobben. Å opprettholde en konsekvent stil, følge beste praksis og sikre typesikkerhet er like avgjørende for å skape robuste, vedlikeholdbare og samarbeidsvennlige prosjekter. Python, kjent for sin lesbarhet, har stor nytte av verktøy som automatiserer disse aspektene. Denne omfattende guiden utforsker integrasjonen av tre kraftige verktøy: Black, Flake8 og mypy, for å heve kvaliteten på Python-koden din til neste nivå.

Hvorfor kodekvalitet er viktig

Før vi dykker ned i detaljene for hvert verktøy, la oss forstå hvorfor kodekvalitet er så viktig:

• Lesbarhet: En konsekvent kodestil gjør det enklere for utviklere å forstå og endre koden.
• Vedlikeholdbarhet: Godt formatert og typesjekket kode reduserer sannsynligheten for feil og forenkler feilsøking.
• Samarbeid: Delte kodestiler sikrer at alle teammedlemmer skriver kode på en enhetlig måte, noe som fremmer sømløst samarbeid.
• Redusert teknisk gjeld: Å håndtere kodekvalitetsproblemer tidlig forhindrer opphopning av teknisk gjeld, noe som sparer tid og ressurser i det lange løp.
• Forbedret pålitelighet: Statisk typesjekking fanger opp potensielle feil før kjøretid, noe som forbedrer den generelle påliteligheten til applikasjonene dine.

Disse fordelene er ikke begrenset til spesifikke bransjer eller regioner. Enten du utvikler en webapplikasjon i Berlin, et datavitenskapsprosjekt i Bangalore, eller en mobilapp i Mexico City, vil konsekvent kodekvalitet utvilsomt forbedre utviklingsflyten din.

Vi introduserer Black: Den kompromissløse kodeformatereren

Black er en kodeformaterer for Python som automatisk reformaterer koden din for å samsvare med en konsekvent stil. Den er "opinionated" (meningssterk), noe som betyr at den tar avgjørelser for deg om hvordan koden skal formateres. Dette minimerer diskusjoner om stil og lar utviklere fokusere på funksjonalitet.

Nøkkelfunksjoner i Black

• Automatisk formatering: Black reformaterer automatisk koden din i henhold til sin forhåndsdefinerte stilguide (basert på PEP 8).
• Kompromissløs: Black gir lite rom for tilpasning, og håndhever en konsekvent stil på tvers av hele kodebasen din.
• Integrasjon med editorer: Black integreres sømløst med populære kodeeditorer som VS Code, PyCharm og Sublime Text.
• Pre-commit hook: Black kan brukes som en pre-commit hook for å sikre at all kode som committes til repositoryet ditt er riktig formatert.

Installere Black

Du kan installere Black ved hjelp av pip:

            pip install black
            

              
                Copy
              
            
          

Bruke Black

For å formatere en Python-fil med Black, kjører du bare følgende kommando:

            black my_file.py
            

              
                Copy
              
            
          

Black vil reformatere filen på stedet, i tråd med sine forhåndsdefinerte stilregler. For å formatere en hel katalog, kjør:

            black my_directory
            

              
                Copy
              
            
          

Eksempel: Formatering med Black

Tenk på følgende dårlig formaterte Python-kode:

            def my_function(  long_argument_name, another_long_argument_name):
    if long_argument_name > 10:
        return  another_long_argument_name   +  long_argument_name
    else:
        return 0
            

              
                Copy
              
            
          

Etter å ha kjørt Black, vil koden automatisk bli reformatert til:

            def my_function(long_argument_name, another_long_argument_name):
    if long_argument_name > 10:
        return another_long_argument_name + long_argument_name
    else:
        return 0
            

              
                Copy
              
            
          

Legg merke til hvordan Black automatisk har justert mellomrom, linjeskift og innrykk for å samsvare med sin stilguide.

Integrere Black med Pre-commit

Pre-commit er et verktøy som lar deg kjøre sjekker på koden din før du committer den til repositoryet. Integrering av Black med pre-commit sikrer at all kode som committes er riktig formatert.

1. Installer pre-commit:

            pip install pre-commit
            

              
                Copy
              
            
          

2. Opprett en .pre-commit-config.yaml-fil i roten av repositoryet ditt:

            repos:
-   repo: https://github.com/psf/black
    rev: 23.12.1  # Erstatt med den nyeste versjonen
    hooks:
    -   id: black
            

              
                Copy
              
            
          

3. Installer pre-commit hooks:

            pre-commit install
            

              
                Copy
              
            
          

Nå, hver gang du committer kode, vil pre-commit kjøre Black for å formatere filene dine. Hvis Black gjør endringer, vil committen bli avbrutt, og du må stage endringene og committe på nytt.

Vi introduserer Flake8: Kontrollverktøyet for kodestil

Flake8 er en "wrapper" rundt flere populære Python linting-verktøy, inkludert pycodestyle (tidligere pep8), pyflakes og mccabe. Den sjekker koden din for stilfeil, syntaksfeil og kompleksitetsproblemer, og hjelper deg med å følge stilguiden PEP 8 og skrive renere, mer vedlikeholdbar kode.

Nøkkelfunksjoner i Flake8

• Oppdagelse av stilfeil: Flake8 identifiserer brudd på stilguiden PEP 8, som feil innrykk, brudd på linjelengde og ubrukte importer.
• Oppdagelse av syntaksfeil: Flake8 oppdager syntaksfeil i koden din, og hjelper deg med å fange potensielle feil tidlig.
• Analyse av kodekompleksitet: Flake8 bruker mccabe til å beregne den syklomatiske kompleksiteten i koden din, og identifiserer potensielt komplekse og vanskelige funksjoner å vedlikeholde.
• Utvidbarhet: Flake8 støtter et bredt spekter av plugins, slik at du kan tilpasse oppførselen og legge til støtte for ytterligere sjekker.

Installere Flake8

Du kan installere Flake8 ved hjelp av pip:

            pip install flake8
            

              
                Copy
              
            
          

Bruke Flake8

For å sjekke en Python-fil med Flake8, kjører du bare følgende kommando:

            flake8 my_file.py
            

              
                Copy
              
            
          

Flake8 vil gi en liste over eventuelle stilfeil, syntaksfeil eller kodekompleksitetsproblemer den finner i filen. For å sjekke en hel katalog, kjør:

            flake8 my_directory
            

              
                Copy
              
            
          

Eksempel: Identifisere stilfeil med Flake8

Tenk på følgende Python-kode:

            def my_function(x,y):
    if x> 10:
        return x+y
    else:
        return 0
            

              
                Copy
              
            
          

Å kjøre Flake8 på denne koden vil produsere følgende output:

            my_file.py:1:1: E302 expected 2 blank lines, found 0
my_file.py:1:14: E231 missing whitespace after ','
my_file.py:2:4: E128 continuation line under-indented for visual indent
my_file.py:3:12: E226 missing whitespace around operator

            

              
                Copy
              
            
          

Flake8 har identifisert flere stilfeil, inkludert manglende blanke linjer, manglende mellomrom etter et komma, feil innrykk og manglende mellomrom rundt en operator. Disse feilene bør rettes for å forbedre kodens lesbarhet og overholdelse av PEP 8.

Konfigurere Flake8

Flake8 kan konfigureres ved hjelp av en .flake8-fil i roten av repositoryet ditt. Denne filen lar deg spesifisere hvilke sjekker som skal aktiveres eller deaktiveres, sette maksimal linjelengde og konfigurere andre innstillinger.

Her er et eksempel på en .flake8-fil:

            [flake8]
max-line-length = 120
ignore = E203, W503
            

              
                Copy
              
            
          

I dette eksempelet er maksimal linjelengde satt til 120 tegn, og sjekkene E203 og W503 er deaktivert. E203 refererer til mellomrom før ':', og anses ofte som en stilistisk preferanse som Black uansett håndterer. W503 refererer til linjeskift før binære operatorer, noe Black også adresserer.

Integrere Flake8 med Pre-commit

For å integrere Flake8 med pre-commit, legg til følgende i din .pre-commit-config.yaml-fil:

            -   repo: https://github.com/pycqa/flake8
    rev: 6.1.0 # Erstatt med den nyeste versjonen
    hooks:
    -   id: flake8
            

              
                Copy
              
            
          

Nå, hver gang du committer kode, vil pre-commit kjøre Flake8 for å se etter stilfeil. Hvis Flake8 finner noen feil, vil committen bli avbrutt, og du må fikse feilene og committe på nytt.

Vi introduserer mypy: Den statiske typesjekkeren

mypy er en statisk typesjekker for Python som hjelper deg med å fange typefeil før kjøretid. Python er et dynamisk typet språk, noe som betyr at typen til en variabel ikke sjekkes før ved kjøretid. Dette kan føre til uventede feil og bugs. mypy lar deg legge til type-hint (type hints) i koden din, noe som muliggjør statisk typesjekking og forbedrer påliteligheten til applikasjonene dine.

Nøkkelfunksjoner i mypy

• Statisk typesjekking: mypy sjekker typene til variabler, funksjonsargumenter og returverdier ved kompileringstid, og fanger potensielle typefeil før kjøretid.
• Type-hint (Type Hints): mypy bruker type-hint, som er annotasjoner som spesifiserer den forventede typen til en variabel eller funksjon.
• Gradvis typing (Gradual Typing): mypy støtter gradvis typing, noe som betyr at du kan legge til type-hint i koden din trinnvis, uten å måtte typesjekke hele kodebasen på en gang.
• Integrasjon med editorer: mypy integreres sømløst med populære kodeeditorer som VS Code og PyCharm.

Installere mypy

Du kan installere mypy ved hjelp av pip:

            pip install mypy
            

              
                Copy
              
            
          

Bruke mypy

For å sjekke en Python-fil med mypy, kjører du bare følgende kommando:

            mypy my_file.py
            

              
                Copy
              
            
          

mypy vil gi en liste over eventuelle typefeil den finner i filen. For å sjekke en hel katalog, kjør:

            mypy my_directory
            

              
                Copy
              
            
          

Eksempel: Legge til type-hint og oppdage typefeil

Tenk på følgende Python-kode:

            def add(x, y):
    return x + y

result = add(10, "20")
print(result)
            

              
                Copy
              
            
          

Denne koden vil kjøre uten feil, men den vil produsere uventede resultater fordi den legger sammen et heltall og en streng. For å fange denne typefeilen, kan du legge til type-hint i add-funksjonen:

            def add(x: int, y: int) -> int:
    return x + y

result = add(10, "20")
print(result)
            

              
                Copy
              
            
          

Nå, når du kjører mypy, vil den gi følgende feilmelding:

            my_file.py:4: error: Argument 2 to "add" has incompatible type "str"; expected "int"
            

              
                Copy
              
            
          

mypy har oppdaget at du sender en streng til add-funksjonen, som forventer et heltall. Dette lar deg fange feilen før kjøretid og forhindre uventet oppførsel.

Konfigurere mypy

mypy kan konfigureres ved hjelp av en mypy.ini- eller pyproject.toml-fil i roten av repositoryet ditt. Denne filen lar deg spesifisere hvilke sjekker som skal aktiveres eller deaktiveres, sette Python-versjonen og konfigurere andre innstillinger. Å bruke pyproject.toml er den moderne, anbefalte tilnærmingen.

Her er et eksempel på en pyproject.toml-fil:

            [tool.mypy]
python_version = "3.11"
strict = true
            

              
                Copy
              
            
          

I dette eksempelet er Python-versjonen satt til 3.11, og strict mode er aktivert. Strict mode aktiverer alle mypys strengeste sjekker, og hjelper deg med å fange enda flere potensielle typefeil.

Integrere mypy med Pre-commit

For å integrere mypy med pre-commit, legg til følgende i din .pre-commit-config.yaml-fil:

            -   repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.6.1 # Erstatt med den nyeste versjonen
    hooks:
    -   id: mypy
            

              
                Copy
              
            
          

Nå, hver gang du committer kode, vil pre-commit kjøre mypy for å se etter typefeil. Hvis mypy finner noen feil, vil committen bli avbrutt, og du må fikse feilene og committe på nytt.

Sette alt sammen: Et komplett integrasjonseksempel

For å demonstrere kraften i å integrere Black, Flake8 og mypy, la oss gå gjennom et komplett eksempel. Tenk på følgende Python-kode:

            def calculate_average(numbers):
    sum=0
    for number in numbers:
        sum+=number
    return sum/len(numbers)
            

              
                Copy
              
            
          

Denne koden har flere problemer:

• Den er ikke formatert i henhold til PEP 8.
• Den mangler type-hint.
• Den bruker et potensielt forvirrende variabelnavn (sum).
• Den håndterer ikke tilfellet der input-listen er tom (divisjon med null).

Først, kjør Black for å formatere koden:

            black my_file.py
            

              
                Copy
              
            
          

Black vil reformatere koden til:

            def calculate_average(numbers):
    sum = 0
    for number in numbers:
        sum += number
    return sum / len(numbers)
            

              
                Copy
              
            
          

Deretter, kjør Flake8 for å se etter stilfeil:

            flake8 my_file.py
            

              
                Copy
              
            
          

Flake8 vil gi følgende feilmeldinger:

            my_file.py:2:1: F841 local variable 'sum' is assigned to but never used
my_file.py:4:11: F821 undefined name 'numbers'

            

              
                Copy
              
            
          

Ved å rette Flake8-feilene (merk at den spesifikke feilmeldingen kan variere avhengig av din flake8-konfigurasjon) og legge til type-hint, blir koden:

            from typing import List

def calculate_average(numbers: List[float]) -> float:
    """Beregner gjennomsnittet av en liste med tall."""
    if not numbers:
        return 0.0  # Unngå divisjon med null
    total = sum(numbers)
    return total / len(numbers)
            

              
                Copy
              
            
          

Til slutt, kjør mypy for å se etter typefeil:

            mypy my_file.py
            

              
                Copy
              
            
          

Hvis det ikke er noen typefeil, vil mypy ikke gi noen output. I dette tilfellet passerer den. Koden er nå formatert i henhold til PEP 8, har type-hint, bruker mer beskrivende variabelnavn og håndterer tilfellet der input-listen er tom. Dette demonstrerer hvordan Black, Flake8 og mypy kan samarbeide for å forbedre kvaliteten og påliteligheten til Python-koden din.

Handlingsrettet innsikt og beste praksis

• Start tidlig: Integrer Black, Flake8 og mypy i utviklingsflyten din fra begynnelsen av prosjektene dine. Dette vil hjelpe deg med å opprettholde en konsekvent kodestil og fange potensielle feil tidlig.
• Konfigurer verktøyene dine: Tilpass Black, Flake8 og mypy for å passe dine spesifikke behov og preferanser. Bruk konfigurasjonsfiler for å spesifisere hvilke sjekker som skal aktiveres eller deaktiveres, sette maksimal linjelengde og konfigurere andre innstillinger.
• Bruk Pre-commit Hooks: Integrer Black, Flake8 og mypy med pre-commit for å sikre at all kode som committes til repositoryet ditt er riktig formatert og typesjekket.
• Automatiser arbeidsflyten din: Bruk CI/CD-pipelines for automatisk å kjøre Black, Flake8 og mypy på hver commit. Dette vil hjelpe deg med å fange kodekvalitetsproblemer før de når produksjon. Tjenester som GitHub Actions, GitLab CI og Jenkins kan konfigureres til å kjøre disse sjekkene automatisk.
• Lær opp teamet ditt: Sørg for at alle teammedlemmer er kjent med Black, Flake8 og mypy og forstår hvordan de skal brukes effektivt. Tilby opplæring og dokumentasjon for å hjelpe teamet ditt med å ta i bruk disse verktøyene og opprettholde en konsekvent kodestil.
• Omfavn gradvis typing: Hvis du jobber med en stor, eksisterende kodebase, bør du vurdere å ta i bruk gradvis typing. Start med å legge til type-hint i de mest kritiske delene av koden din og utvid dekningen gradvis over tid.

Konklusjon

Å investere i kodekvalitet er en investering i den langsiktige suksessen til prosjektene dine. Ved å integrere Black, Flake8 og mypy i utviklingsflyten din, kan du betydelig forbedre lesbarheten, vedlikeholdbarheten og påliteligheten til Python-koden din. Disse verktøyene er essensielle for enhver seriøs Python-utvikler, uavhengig av deres lokasjon eller arten av prosjektene deres. Fra startups i Silicon Valley til etablerte bedrifter i Singapore, vil omfavnelse av disse beste praksisene utvilsomt føre til mer effektiv og vellykket programvareutvikling.

Husk å tilpasse disse retningslinjene og verktøyene til din spesifikke kontekst. Eksperimenter med forskjellige konfigurasjoner, utforsk tilgjengelige plugins, og skreddersy arbeidsflyten din for å møte de unike behovene til teamet og prosjektene dine. Ved kontinuerlig å strebe etter høyere kodekvalitet, vil du være godt posisjonert til å bygge robuste, skalerbare og vedlikeholdbare applikasjoner som leverer verdi til brukerne dine i mange år fremover.